/* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
/*
   Copyright 2011 notmasteryet

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

// - The JPEG specification can be found in the ITU CCITT Recommendation T.81
//   (www.w3.org/Graphics/JPEG/itu-t81.pdf)
// - The JFIF specification can be found in the JPEG File Interchange Format
//   (www.w3.org/Graphics/JPEG/jfif3.pdf)
// - The Adobe Application-Specific JPEG markers in the Supporting the DCT Filters
//   in PostScript Level 2, Technical Note #5116
//   (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf)

var JpegImage = (function jpegImage () {
  'use strict'
  var dctZigZag = new Int32Array([
    0,
    1, 8,
    16, 9, 2,
    3, 10, 17, 24,
    32, 25, 18, 11, 4,
    5, 12, 19, 26, 33, 40,
    48, 41, 34, 27, 20, 13, 6,
    7, 14, 21, 28, 35, 42, 49, 56,
    57, 50, 43, 36, 29, 22, 15,
    23, 30, 37, 44, 51, 58,
    59, 52, 45, 38, 31,
    39, 46, 53, 60,
    61, 54, 47,
    55, 62,
    63
  ])

  var dctCos1 = 4017 // cos(pi/16)
  var dctSin1 = 799 // sin(pi/16)
  var dctCos3 = 3406 // cos(3*pi/16)
  var dctSin3 = 2276 // sin(3*pi/16)
  var dctCos6 = 1567 // cos(6*pi/16)
  var dctSin6 = 3784 // sin(6*pi/16)
  var dctSqrt2 = 5793 // sqrt(2)
  var dctSqrt1d2 = 2896 // sqrt(2) / 2

  function constructor () {
  }

  function buildHuffmanTable (codeLengths, values) {
    var k = 0, code = [], i, j, length = 16
    while (length > 0 && !codeLengths[length - 1]) { length-- }
    code.push({children: [], index: 0})
    var p = code[0], q
    for (i = 0; i < length; i++) {
      for (j = 0; j < codeLengths[i]; j++) {
        p = code.pop()
        p.children[p.index] = values[k]
        while (p.index > 0) {
          p = code.pop()
        }
        p.index++
        code.push(p)
        while (code.length <= i) {
          code.push(q = {children: [], index: 0})
          p.children[p.index] = q.children
          p = q
        }
        k++
      }
      if (i + 1 < length) {
        // p here points to last code
        code.push(q = {children: [], index: 0})
        p.children[p.index] = q.children
        p = q
      }
    }
    return code[0].children
  }

  function decodeScan (data, offset,
    frame, components, resetInterval,
    spectralStart, spectralEnd,
    successivePrev, successive) {
    var precision = frame.precision
    var samplesPerLine = frame.samplesPerLine
    var scanLines = frame.scanLines
    var mcusPerLine = frame.mcusPerLine
    var progressive = frame.progressive
    var maxH = frame.maxH, maxV = frame.maxV

    var startOffset = offset, bitsData = 0, bitsCount = 0
    function readBit () {
      if (bitsCount > 0) {
        bitsCount--
        return (bitsData >> bitsCount) & 1
      }
      bitsData = data[offset++]
      if (bitsData === 0xFF) {
        var nextByte = data[offset++]
        if (nextByte) {
          throw new Error('unexpected marker: ' + ((bitsData << 8) | nextByte).toString(16))
        }
        // unstuff 0
      }
      bitsCount = 7
      return bitsData >>> 7
    }
    function decodeHuffman (tree) {
      var node = tree, bit
      while ((bit = readBit()) !== null) {
        node = node[bit]
        if (typeof node === 'number') { return node }
        if (typeof node !== 'object') { throw new Error('invalid huffman sequence') }
      }
      return null
    }
    function receive (length) {
      var n = 0
      while (length > 0) {
        var bit = readBit()
        if (bit === null) return
        n = (n << 1) | bit
        length--
      }
      return n
    }
    function receiveAndExtend (length) {
      var n = receive(length)
      if (n >= 1 << (length - 1)) { return n }
      return n + (-1 << length) + 1
    }
    function decodeBaseline (component, zz) {
      var t = decodeHuffman(component.huffmanTableDC)
      var diff = t === 0 ? 0 : receiveAndExtend(t)
      zz[0] = (component.pred += diff)
      var k = 1
      while (k < 64) {
        var rs = decodeHuffman(component.huffmanTableAC)
        var s = rs & 15, r = rs >> 4
        if (s === 0) {
          if (r < 15) { break }
          k += 16
          continue
        }
        k += r
        var z = dctZigZag[k]
        zz[z] = receiveAndExtend(s)
        k++
      }
    }
    function decodeDCFirst (component, zz) {
      var t = decodeHuffman(component.huffmanTableDC)
      var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive)
      zz[0] = (component.pred += diff)
    }
    function decodeDCSuccessive (component, zz) {
      zz[0] |= readBit() << successive
    }
    var eobrun = 0
    function decodeACFirst (component, zz) {
      if (eobrun > 0) {
        eobrun--
        return
      }
      var k = spectralStart, e = spectralEnd
      while (k <= e) {
        var rs = decodeHuffman(component.huffmanTableAC)
        var s = rs & 15, r = rs >> 4
        if (s === 0) {
          if (r < 15) {
            eobrun = receive(r) + (1 << r) - 1
            break
          }
          k += 16
          continue
        }
        k += r
        var z = dctZigZag[k]
        zz[z] = receiveAndExtend(s) * (1 << successive)
        k++
      }
    }
    var successiveACState = 0, successiveACNextValue
    function decodeACSuccessive (component, zz) {
      var k = spectralStart, e = spectralEnd, r = 0
      while (k <= e) {
        var z = dctZigZag[k]
        var direction = zz[z] < 0 ? -1 : 1
        switch (successiveACState) {
          case 0: // initial state
            var rs = decodeHuffman(component.huffmanTableAC)
            var s = rs & 15, r = rs >> 4
            if (s === 0) {
              if (r < 15) {
                eobrun = receive(r) + (1 << r)
                successiveACState = 4
              } else {
                r = 16
                successiveACState = 1
              }
            } else {
              if (s !== 1) { throw new Error('invalid ACn encoding') }
              successiveACNextValue = receiveAndExtend(s)
              successiveACState = r ? 2 : 3
            }
            continue
          case 1: // skipping r zero items
          case 2:
            if (zz[z]) { zz[z] += (readBit() << successive) * direction } else {
              r--
              if (r === 0) { successiveACState = successiveACState == 2 ? 3 : 0 }
            }
            break
          case 3: // set value for a zero item
            if (zz[z]) { zz[z] += (readBit() << successive) * direction } else {
              zz[z] = successiveACNextValue << successive
              successiveACState = 0
            }
            break
          case 4: // eob
            if (zz[z]) { zz[z] += (readBit() << successive) * direction }
            break
        }
        k++
      }
      if (successiveACState === 4) {
        eobrun--
        if (eobrun === 0) { successiveACState = 0 }
      }
    }
    function decodeMcu (component, decode, mcu, row, col) {
      var mcuRow = (mcu / mcusPerLine) | 0
      var mcuCol = mcu % mcusPerLine
      var blockRow = mcuRow * component.v + row
      var blockCol = mcuCol * component.h + col
      decode(component, component.blocks[blockRow][blockCol])
    }
    function decodeBlock (component, decode, mcu) {
      var blockRow = (mcu / component.blocksPerLine) | 0
      var blockCol = mcu % component.blocksPerLine
      decode(component, component.blocks[blockRow][blockCol])
    }

    var componentsLength = components.length
    var component, i, j, k, n
    var decodeFn
    if (progressive) {
      if (spectralStart === 0) { decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive } else { decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive }
    } else {
      decodeFn = decodeBaseline
    }

    var mcu = 0, marker
    var mcuExpected
    if (componentsLength == 1) {
      mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn
    } else {
      mcuExpected = mcusPerLine * frame.mcusPerColumn
    }
    if (!resetInterval) resetInterval = mcuExpected

    var h, v
    while (mcu < mcuExpected) {
      // reset interval stuff
      for (i = 0; i < componentsLength; i++) { components[i].pred = 0 }
      eobrun = 0

      if (componentsLength === 1) {
        component = components[0]
        for (n = 0; n < resetInterval; n++) {
          decodeBlock(component, decodeFn, mcu)
          mcu++
        }
      } else {
        for (n = 0; n < resetInterval; n++) {
          for (i = 0; i < componentsLength; i++) {
            component = components[i]
            h = component.h
            v = component.v
            for (j = 0; j < v; j++) {
              for (k = 0; k < h; k++) {
                decodeMcu(component, decodeFn, mcu, j, k)
              }
            }
          }
          mcu++

          // If we've reached our expected MCU's, stop decoding
          if (mcu === mcuExpected) break
        }
      }

      // find marker
      bitsCount = 0
      marker = (data[offset] << 8) | data[offset + 1]
      if (marker < 0xFF00) {
        throw new Error('marker was not found')
      }

      if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
        offset += 2
      } else { break }
    }

    return offset - startOffset
  }

  function buildComponentData (frame, component) {
    var lines = []
    var blocksPerLine = component.blocksPerLine
    var blocksPerColumn = component.blocksPerColumn
    var samplesPerLine = blocksPerLine << 3
    var R = new Int32Array(64), r = new Uint8Array(64)

    // A port of poppler's IDCT method which in turn is taken from:
    //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
    //   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
    //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
    //   988-991.
    function quantizeAndInverse (zz, dataOut, dataIn) {
      var qt = component.quantizationTable
      var v0, v1, v2, v3, v4, v5, v6, v7, t
      var p = dataIn
      var i

      // dequant
      for (i = 0; i < 64; i++) { p[i] = zz[i] * qt[i] }

      // inverse DCT on rows
      for (i = 0; i < 8; ++i) {
        var row = 8 * i

        // check for all-zero AC coefficients
        if (p[1 + row] === 0 && p[2 + row] === 0 && p[3 + row] === 0 &&
            p[4 + row] === 0 && p[5 + row] === 0 && p[6 + row] === 0 &&
            p[7 + row] === 0) {
          t = (dctSqrt2 * p[0 + row] + 512) >> 10
          p[0 + row] = t
          p[1 + row] = t
          p[2 + row] = t
          p[3 + row] = t
          p[4 + row] = t
          p[5 + row] = t
          p[6 + row] = t
          p[7 + row] = t
          continue
        }

        // stage 4
        v0 = (dctSqrt2 * p[0 + row] + 128) >> 8
        v1 = (dctSqrt2 * p[4 + row] + 128) >> 8
        v2 = p[2 + row]
        v3 = p[6 + row]
        v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8
        v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8
        v5 = p[3 + row] << 4
        v6 = p[5 + row] << 4

        // stage 3
        t = (v0 - v1 + 1) >> 1
        v0 = (v0 + v1 + 1) >> 1
        v1 = t
        t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8
        v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8
        v3 = t
        t = (v4 - v6 + 1) >> 1
        v4 = (v4 + v6 + 1) >> 1
        v6 = t
        t = (v7 + v5 + 1) >> 1
        v5 = (v7 - v5 + 1) >> 1
        v7 = t

        // stage 2
        t = (v0 - v3 + 1) >> 1
        v0 = (v0 + v3 + 1) >> 1
        v3 = t
        t = (v1 - v2 + 1) >> 1
        v1 = (v1 + v2 + 1) >> 1
        v2 = t
        t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12
        v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12
        v7 = t
        t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12
        v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12
        v6 = t

        // stage 1
        p[0 + row] = v0 + v7
        p[7 + row] = v0 - v7
        p[1 + row] = v1 + v6
        p[6 + row] = v1 - v6
        p[2 + row] = v2 + v5
        p[5 + row] = v2 - v5
        p[3 + row] = v3 + v4
        p[4 + row] = v3 - v4
      }

      // inverse DCT on columns
      for (i = 0; i < 8; ++i) {
        var col = i

        // check for all-zero AC coefficients
        if (p[1 * 8 + col] === 0 && p[2 * 8 + col] === 0 && p[3 * 8 + col] === 0 &&
            p[4 * 8 + col] === 0 && p[5 * 8 + col] === 0 && p[6 * 8 + col] === 0 &&
            p[7 * 8 + col] === 0) {
          t = (dctSqrt2 * dataIn[i + 0] + 8192) >> 14
          p[0 * 8 + col] = t
          p[1 * 8 + col] = t
          p[2 * 8 + col] = t
          p[3 * 8 + col] = t
          p[4 * 8 + col] = t
          p[5 * 8 + col] = t
          p[6 * 8 + col] = t
          p[7 * 8 + col] = t
          continue
        }

        // stage 4
        v0 = (dctSqrt2 * p[0 * 8 + col] + 2048) >> 12
        v1 = (dctSqrt2 * p[4 * 8 + col] + 2048) >> 12
        v2 = p[2 * 8 + col]
        v3 = p[6 * 8 + col]
        v4 = (dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048) >> 12
        v7 = (dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048) >> 12
        v5 = p[3 * 8 + col]
        v6 = p[5 * 8 + col]

        // stage 3
        t = (v0 - v1 + 1) >> 1
        v0 = (v0 + v1 + 1) >> 1
        v1 = t
        t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12
        v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12
        v3 = t
        t = (v4 - v6 + 1) >> 1
        v4 = (v4 + v6 + 1) >> 1
        v6 = t
        t = (v7 + v5 + 1) >> 1
        v5 = (v7 - v5 + 1) >> 1
        v7 = t

        // stage 2
        t = (v0 - v3 + 1) >> 1
        v0 = (v0 + v3 + 1) >> 1
        v3 = t
        t = (v1 - v2 + 1) >> 1
        v1 = (v1 + v2 + 1) >> 1
        v2 = t
        t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12
        v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12
        v7 = t
        t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12
        v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12
        v6 = t

        // stage 1
        p[0 * 8 + col] = v0 + v7
        p[7 * 8 + col] = v0 - v7
        p[1 * 8 + col] = v1 + v6
        p[6 * 8 + col] = v1 - v6
        p[2 * 8 + col] = v2 + v5
        p[5 * 8 + col] = v2 - v5
        p[3 * 8 + col] = v3 + v4
        p[4 * 8 + col] = v3 - v4
      }

      // convert to 8-bit integers
      for (i = 0; i < 64; ++i) {
        var sample = 128 + ((p[i] + 8) >> 4)
        dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample
      }
    }

    var i, j
    for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
      var scanLine = blockRow << 3
      for (i = 0; i < 8; i++) { lines.push(new Uint8Array(samplesPerLine)) }
      for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
        quantizeAndInverse(component.blocks[blockRow][blockCol], r, R)

        var offset = 0, sample = blockCol << 3
        for (j = 0; j < 8; j++) {
          var line = lines[scanLine + j]
          for (i = 0; i < 8; i++) { line[sample + i] = r[offset++] }
        }
      }
    }
    return lines
  }

  function clampTo8bit (a) {
    return a < 0 ? 0 : a > 255 ? 255 : a
  }

  constructor.prototype = {
    load: function load (path) {
      var xhr = new XMLHttpRequest()
      xhr.open('GET', path, true)
      xhr.responseType = 'arraybuffer'
      xhr.onload = function () {
        // TODO catch parse error
        var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer)
        this.parse(data)
        if (this.onload) { this.onload() }
      }.bind(this)
      xhr.send(null)
    },
    parse: function parse (data) {
      var offset = 0, length = data.length
      function readUint16 () {
        var value = (data[offset] << 8) | data[offset + 1]
        offset += 2
        return value
      }
      function readDataBlock () {
        var length = readUint16()
        var array = data.subarray(offset, offset + length - 2)
        offset += array.length
        return array
      }
      function prepareComponents (frame) {
        var maxH = 0, maxV = 0
        var component, componentId
        for (componentId in frame.components) {
          if (frame.components.hasOwnProperty(componentId)) {
            component = frame.components[componentId]
            if (maxH < component.h) maxH = component.h
            if (maxV < component.v) maxV = component.v
          }
        }
        var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH)
        var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV)
        for (componentId in frame.components) {
          if (frame.components.hasOwnProperty(componentId)) {
            component = frame.components[componentId]
            var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH)
            var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV)
            var blocksPerLineForMcu = mcusPerLine * component.h
            var blocksPerColumnForMcu = mcusPerColumn * component.v
            var blocks = []
            for (var i = 0; i < blocksPerColumnForMcu; i++) {
              var row = []
              for (var j = 0; j < blocksPerLineForMcu; j++) { row.push(new Int32Array(64)) }
              blocks.push(row)
            }
            component.blocksPerLine = blocksPerLine
            component.blocksPerColumn = blocksPerColumn
            component.blocks = blocks
          }
        }
        frame.maxH = maxH
        frame.maxV = maxV
        frame.mcusPerLine = mcusPerLine
        frame.mcusPerColumn = mcusPerColumn
      }
      var jfif = null
      var adobe = null
      var pixels = null
      var frame, resetInterval
      var quantizationTables = [], frames = []
      var huffmanTablesAC = [], huffmanTablesDC = []
      var fileMarker = readUint16()
      if (fileMarker != 0xFFD8) { // SOI (Start of Image)
        throw new Error('SOI not found')
      }

      fileMarker = readUint16()
      while (fileMarker != 0xFFD9) { // EOI (End of image)
        var i, j, l
        switch (fileMarker) {
          case 0xFF00: break
          case 0xFFE0: // APP0 (Application Specific)
          case 0xFFE1: // APP1
          case 0xFFE2: // APP2
          case 0xFFE3: // APP3
          case 0xFFE4: // APP4
          case 0xFFE5: // APP5
          case 0xFFE6: // APP6
          case 0xFFE7: // APP7
          case 0xFFE8: // APP8
          case 0xFFE9: // APP9
          case 0xFFEA: // APP10
          case 0xFFEB: // APP11
          case 0xFFEC: // APP12
          case 0xFFED: // APP13
          case 0xFFEE: // APP14
          case 0xFFEF: // APP15
          case 0xFFFE: // COM (Comment)
            var appData = readDataBlock()

            if (fileMarker === 0xFFE0) {
              if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 &&
                appData[3] === 0x46 && appData[4] === 0) { // 'JFIF\x00'
                jfif = {
                  version: { major: appData[5], minor: appData[6] },
                  densityUnits: appData[7],
                  xDensity: (appData[8] << 8) | appData[9],
                  yDensity: (appData[10] << 8) | appData[11],
                  thumbWidth: appData[12],
                  thumbHeight: appData[13],
                  thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
                }
              }
            }
            // TODO APP1 - Exif
            if (fileMarker === 0xFFEE) {
              if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F &&
                appData[3] === 0x62 && appData[4] === 0x65 && appData[5] === 0) { // 'Adobe\x00'
                adobe = {
                  version: appData[6],
                  flags0: (appData[7] << 8) | appData[8],
                  flags1: (appData[9] << 8) | appData[10],
                  transformCode: appData[11]
                }
              }
            }
            break

          case 0xFFDB: // DQT (Define Quantization Tables)
            var quantizationTablesLength = readUint16()
            var quantizationTablesEnd = quantizationTablesLength + offset - 2
            while (offset < quantizationTablesEnd) {
              var quantizationTableSpec = data[offset++]
              var tableData = new Int32Array(64)
              if ((quantizationTableSpec >> 4) === 0) { // 8 bit values
                for (j = 0; j < 64; j++) {
                  var z = dctZigZag[j]
                  tableData[z] = data[offset++]
                }
              } else if ((quantizationTableSpec >> 4) === 1) { // 16 bit
                for (j = 0; j < 64; j++) {
                  var z = dctZigZag[j]
                  tableData[z] = readUint16()
                }
              } else { throw new Error('DQT: invalid table spec') }
              quantizationTables[quantizationTableSpec & 15] = tableData
            }
            break

          case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT)
          case 0xFFC1: // SOF1 (Start of Frame, Extended DCT)
          case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT)
            readUint16() // skip data length
            frame = {}
            frame.extended = (fileMarker === 0xFFC1)
            frame.progressive = (fileMarker === 0xFFC2)
            frame.precision = data[offset++]
            frame.scanLines = readUint16()
            frame.samplesPerLine = readUint16()
            frame.components = {}
            frame.componentsOrder = []
            var componentsCount = data[offset++], componentId
            var maxH = 0, maxV = 0
            for (i = 0; i < componentsCount; i++) {
              componentId = data[offset]
              var h = data[offset + 1] >> 4
              var v = data[offset + 1] & 15
              var qId = data[offset + 2]
              frame.componentsOrder.push(componentId)
              frame.components[componentId] = {
                h: h,
                v: v,
                quantizationIdx: qId
              }
              offset += 3
            }
            prepareComponents(frame)
            frames.push(frame)
            break

          case 0xFFC4: // DHT (Define Huffman Tables)
            var huffmanLength = readUint16()
            for (i = 2; i < huffmanLength;) {
              var huffmanTableSpec = data[offset++]
              var codeLengths = new Uint8Array(16)
              var codeLengthSum = 0
              for (j = 0; j < 16; j++, offset++) { codeLengthSum += (codeLengths[j] = data[offset]) }
              var huffmanValues = new Uint8Array(codeLengthSum)
              for (j = 0; j < codeLengthSum; j++, offset++) { huffmanValues[j] = data[offset] }
              i += 17 + codeLengthSum;

              ((huffmanTableSpec >> 4) === 0
                ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] =
                buildHuffmanTable(codeLengths, huffmanValues)
            }
            break

          case 0xFFDD: // DRI (Define Restart Interval)
            readUint16() // skip data length
            resetInterval = readUint16()
            break

          case 0xFFDA: // SOS (Start of Scan)
            var scanLength = readUint16()
            var selectorsCount = data[offset++]
            var components = [], component
            for (i = 0; i < selectorsCount; i++) {
              component = frame.components[data[offset++]]
              var tableSpec = data[offset++]
              component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]
              component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]
              components.push(component)
            }
            var spectralStart = data[offset++]
            var spectralEnd = data[offset++]
            var successiveApproximation = data[offset++]
            var processed = decodeScan(data, offset,
              frame, components, resetInterval,
              spectralStart, spectralEnd,
              successiveApproximation >> 4, successiveApproximation & 15)
            offset += processed
            break

          case 0xFFFF: // Fill bytes
            if (data[offset] !== 0xFF) { // Avoid skipping a valid marker.
              offset--
            }
            break

          default:
            if (data[offset - 3] == 0xFF &&
                data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
              // could be incorrect encoding -- last 0xFF byte of the previous
              // block was eaten by the encoder
              offset -= 3
              break
            }
            throw new Error('unknown JPEG marker ' + fileMarker.toString(16))
        }
        fileMarker = readUint16()
      }
      if (frames.length != 1) { throw new Error('only single frame JPEGs supported') }

      // set each frame's components quantization table
      for (var i = 0; i < frames.length; i++) {
        var cp = frames[i].components
        for (var j in cp) {
          cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx]
          delete cp[j].quantizationIdx
        }
      }

      this.width = frame.samplesPerLine
      this.height = frame.scanLines
      this.jfif = jfif
      this.adobe = adobe
      this.components = []
      for (var i = 0; i < frame.componentsOrder.length; i++) {
        var component = frame.components[frame.componentsOrder[i]]
        this.components.push({
          lines: buildComponentData(frame, component),
          scaleX: component.h / frame.maxH,
          scaleY: component.v / frame.maxV
        })
      }
    },
    getData: function getData (width, height) {
      var scaleX = this.width / width, scaleY = this.height / height

      var component1, component2, component3, component4
      var component1Line, component2Line, component3Line, component4Line
      var x, y
      var offset = 0
      var Y, Cb, Cr, K, C, M, Ye, R, G, B
      var colorTransform
      var dataLength = width * height * this.components.length
      var data = new Uint8Array(dataLength)
      switch (this.components.length) {
        case 1:
          component1 = this.components[0]
          for (y = 0; y < height; y++) {
            component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]
            for (x = 0; x < width; x++) {
              Y = component1Line[0 | (x * component1.scaleX * scaleX)]

              data[offset++] = Y
            }
          }
          break
        case 2:
          // PDF might compress two component data in custom colorspace
          component1 = this.components[0]
          component2 = this.components[1]
          for (y = 0; y < height; y++) {
            component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]
            component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]
            for (x = 0; x < width; x++) {
              Y = component1Line[0 | (x * component1.scaleX * scaleX)]
              data[offset++] = Y
              Y = component2Line[0 | (x * component2.scaleX * scaleX)]
              data[offset++] = Y
            }
          }
          break
        case 3:
          // The default transform for three components is true
          colorTransform = true
          // The adobe transform marker overrides any previous setting
          if (this.adobe && this.adobe.transformCode) { colorTransform = true } else if (typeof this.colorTransform !== 'undefined') { colorTransform = !!this.colorTransform }

          component1 = this.components[0]
          component2 = this.components[1]
          component3 = this.components[2]
          for (y = 0; y < height; y++) {
            component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]
            component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]
            component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]
            for (x = 0; x < width; x++) {
              if (!colorTransform) {
                R = component1Line[0 | (x * component1.scaleX * scaleX)]
                G = component2Line[0 | (x * component2.scaleX * scaleX)]
                B = component3Line[0 | (x * component3.scaleX * scaleX)]
              } else {
                Y = component1Line[0 | (x * component1.scaleX * scaleX)]
                Cb = component2Line[0 | (x * component2.scaleX * scaleX)]
                Cr = component3Line[0 | (x * component3.scaleX * scaleX)]

                R = clampTo8bit(Y + 1.402 * (Cr - 128))
                G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128))
                B = clampTo8bit(Y + 1.772 * (Cb - 128))
              }

              data[offset++] = R
              data[offset++] = G
              data[offset++] = B
            }
          }
          break
        case 4:
          if (!this.adobe) { throw new Error('Unsupported color mode (4 components)') }
          // The default transform for four components is false
          colorTransform = false
          // The adobe transform marker overrides any previous setting
          if (this.adobe && this.adobe.transformCode) { colorTransform = true } else if (typeof this.colorTransform !== 'undefined') { colorTransform = !!this.colorTransform }

          component1 = this.components[0]
          component2 = this.components[1]
          component3 = this.components[2]
          component4 = this.components[3]
          for (y = 0; y < height; y++) {
            component1Line = component1.lines[0 | (y * component1.scaleY * scaleY)]
            component2Line = component2.lines[0 | (y * component2.scaleY * scaleY)]
            component3Line = component3.lines[0 | (y * component3.scaleY * scaleY)]
            component4Line = component4.lines[0 | (y * component4.scaleY * scaleY)]
            for (x = 0; x < width; x++) {
              if (!colorTransform) {
                C = component1Line[0 | (x * component1.scaleX * scaleX)]
                M = component2Line[0 | (x * component2.scaleX * scaleX)]
                Ye = component3Line[0 | (x * component3.scaleX * scaleX)]
                K = component4Line[0 | (x * component4.scaleX * scaleX)]
              } else {
                Y = component1Line[0 | (x * component1.scaleX * scaleX)]
                Cb = component2Line[0 | (x * component2.scaleX * scaleX)]
                Cr = component3Line[0 | (x * component3.scaleX * scaleX)]
                K = component4Line[0 | (x * component4.scaleX * scaleX)]

                C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128))
                M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128))
                Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128))
              }
              data[offset++] = 255 - C
              data[offset++] = 255 - M
              data[offset++] = 255 - Ye
              data[offset++] = 255 - K
            }
          }
          break
        default:
          throw new Error('Unsupported color mode')
      }
      return data
    },
    copyToImageData: function copyToImageData (imageData) {
      var width = imageData.width, height = imageData.height
      var imageDataArray = imageData.data
      var data = this.getData(width, height)
      var i = 0, j = 0, x, y
      var Y, K, C, M, R, G, B
      switch (this.components.length) {
        case 1:
          for (y = 0; y < height; y++) {
            for (x = 0; x < width; x++) {
              Y = data[i++]

              imageDataArray[j++] = Y
              imageDataArray[j++] = Y
              imageDataArray[j++] = Y
              imageDataArray[j++] = 255
            }
          }
          break
        case 3:
          for (y = 0; y < height; y++) {
            for (x = 0; x < width; x++) {
              R = data[i++]
              G = data[i++]
              B = data[i++]

              imageDataArray[j++] = R
              imageDataArray[j++] = G
              imageDataArray[j++] = B
              imageDataArray[j++] = 255
            }
          }
          break
        case 4:
          for (y = 0; y < height; y++) {
            for (x = 0; x < width; x++) {
              C = data[i++]
              M = data[i++]
              Y = data[i++]
              K = data[i++]

              R = 255 - clampTo8bit(C * (1 - K / 255) + K)
              G = 255 - clampTo8bit(M * (1 - K / 255) + K)
              B = 255 - clampTo8bit(Y * (1 - K / 255) + K)

              imageDataArray[j++] = R
              imageDataArray[j++] = G
              imageDataArray[j++] = B
              imageDataArray[j++] = 255
            }
          }
          break
        default:
          throw new Error('Unsupported color mode')
      }
    }
  }

  return constructor
})()
// module.exports = decode;

function decode (jpegData, opts) {
  var defaultOpts = {
    useTArray: false,
    colorTransform: true
  }
  if (opts) {
    if (typeof opts === 'object') {
      opts = {
        useTArray: (typeof opts.useTArray === 'undefined'
          ? defaultOpts.useTArray : opts.useTArray),
        colorTransform: (typeof opts.colorTransform === 'undefined'
          ? defaultOpts.colorTransform : opts.colorTransform)
      }
    } else {
      // backwards compatiblity, before 0.3.5, we only had the useTArray param
      opts = defaultOpts
      opts.useTArray = true
    }
  } else {
    opts = defaultOpts
  }

  var arr = new Uint8Array(jpegData)
  var decoder = new JpegImage()
  decoder.parse(arr)
  decoder.colorTransform = opts.colorTransform

  var image = {
    width: decoder.width,
    height: decoder.height,
    data: new Uint8Array(decoder.width * decoder.height * 4)
  }

  decoder.copyToImageData(image)

  return image
}

export {decode}
